﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Entidades;
using AccesoADatos;

namespace LogicaDeNegocios
{
    public class Preguntas
    {
        #region Campos

        AuxiliarPregunta Auxiliar;

        #endregion

        #region Constructor

        public Preguntas()
        {
            Auxiliar = new AuxiliarPregunta();
        }

        #endregion

        #region Métodos

        #region Agregar Pregunta

        public bool Agregar(Pregunta nuevaPregunta)
        {
            bool resultado = false;

            try
            {
                
                Pregunta preguntaAgregada = Auxiliar.Agregar(nuevaPregunta);                

                if (preguntaAgregada != null)
                {
                    resultado = true;
                }

            }            
            catch (Exception ex)
            {                
                throw ex;
            }

            return resultado;
        }



        #endregion

        #region Modificar Pregunta

        public bool Modificar(Pregunta preguntaAModificar)
        {
            bool resultado = false;

            try
            {
                Auxiliar.Modificar(preguntaAModificar);
                resultado = true;

            }
            catch (Exception ex)
            {                
                throw ex;
            }

            return resultado;
        }
        #endregion

        #region Eliminar Pregunta

        public bool Eliminar(Pregunta preguntaAEliminar)
        {
            bool resultado = false;

            try
            {
                Auxiliar.Eliminar(preguntaAEliminar);
                resultado = true;

            }
            catch (Exception ex)
            {                
                throw ex;
            }

            return resultado;
        }

        #endregion      

        #region Obtener Preguntas 

        public List<Pregunta> ObtenerPreguntas(string examenClave = "", short habilidadId = 0, short id = 0)
        {
            List<Pregunta> resultado = null;

            try
            {
                resultado = Auxiliar.Listar(examenClave, habilidadId, id);
            }
            catch (Exception ex)
            {
                throw (ex);
            }

            return resultado;
        }

        #endregion

        #region Obtener Pregunta
        
        public Pregunta ObtenerPregunta(string examenClave, short habilidadId, short id)
        {
            Pregunta resultado = null;

            try
            {
                resultado = ObtenerPreguntas(examenClave, habilidadId, id).FirstOrDefault();                       

            }
            catch (Exception ex)
            {
                throw (ex);
            }
            return resultado;
        }

        #endregion      

        #region Verificar si es ultima pregunta
 
        public bool VerifiarSiEsUltimaPregunta(string claveExamen, string codigoExamen)
        {
            LogicaDeNegocios.Examenes e = new LogicaDeNegocios.Examenes();

            short noPreguntasExamen = e.ObtenerExamen(claveExamen).NumeroPreguntas;

            LogicaDeNegocios.ExamenesCodigos ec = new LogicaDeNegocios.ExamenesCodigos();

            short cantidadPreguntasRespondidas = ec.ObtenerCodigoExamen(codigoExamen).CantidadPreguntasRespondidas;

            return (noPreguntasExamen) >= cantidadPreguntasRespondidas + 1 ? false : true;
        }

        #endregion
        
        #region Obtener Pregunta Aleatoria 

        public PreguntaAleatoria ObtenerPreguntaAleatoria(string examenClave, string examenCodigo)
        {
            var historiales = new LogicaDeNegocios.Historiales();

            var ultimoHistorial = historiales.ObtenerHistoriales(examenCodigo).OrderBy(h => h.FechaHoraInicio).LastOrDefault();

            Habilidades habilidades = new Habilidades();
            short preguntaHabilidadId = habilidades.ObtenerIdHabilidadAleatoria(examenClave, examenCodigo, ultimoHistorial.FechaHoraInicio);

            PreguntaAleatoria resultado = null;

            var listaPreguntasDeHabilidad = this.ObtenerPreguntas(examenClave, preguntaHabilidadId);
            var listaIdPreguntasDeHabilidad = listaPreguntasDeHabilidad.Select(p => p.Id);

            var listaPreguntasDeHabilidadEnviadas = new LogicaDeNegocios.ExamenesPreguntas().Listar(examenCodigo, examenClave, preguntaHabilidadId);
            var listaIdPreguntasDeHabilidadEnviados = listaPreguntasDeHabilidadEnviadas.Select(pe => pe.PreguntasId);

            bool seleccionMultiple = false;

            var aIdPreguntasExamen = listaIdPreguntasDeHabilidad.ToArray();

            var aIdPregRespondidasYNoRespondidas = listaIdPreguntasDeHabilidadEnviados.ToArray();

            short idPreguntaSeleccionada;

            bool preguntaEnviadaAntes;

            do
            {
                int indiceSeleccionado = new Random().Next(listaPreguntasDeHabilidad.Count);
                idPreguntaSeleccionada = Convert.ToInt16(aIdPreguntasExamen.GetValue(indiceSeleccionado));
                preguntaEnviadaAntes = aIdPregRespondidasYNoRespondidas.Contains(idPreguntaSeleccionada);

            } while (preguntaEnviadaAntes);

            Pregunta preguntaSeleccionada = listaPreguntasDeHabilidad.Where(p => p.Id == idPreguntaSeleccionada).FirstOrDefault();


            if (preguntaSeleccionada != null)
            {
                string consecutivosRespuestas = preguntaSeleccionada.ConsecutivosRespuestasCorrecta;
                seleccionMultiple = consecutivosRespuestas.Length > 1 ? true : false;

                resultado = new PreguntaAleatoria
                {
                    Id = preguntaSeleccionada.Id,
                    Enunciado = preguntaSeleccionada.Enunciado,
                    Comentario = preguntaSeleccionada.Comentario,
                    Referencia = preguntaSeleccionada.Referencia,
                    TiempoEstimado = preguntaSeleccionada.TiempoEstimado,
                    OpcionMultiple = seleccionMultiple,
                    HabilidadesId = preguntaSeleccionada.HabilidadesId,
                    ConsecutivosRespuestasCorrecta = preguntaSeleccionada.ConsecutivosRespuestasCorrecta,
                    ExamenesClave = preguntaSeleccionada.ExamenesClave

                };
            }
            return resultado;
        }

        #endregion

        #region Calificar Pregunta

        public bool CalificarPregunta(PreguntaAleatoria pregunta, char[] respuestas)
        {
            Array.Sort(respuestas);

            string rtasUsuario = new string(respuestas);            

            char[] arrRespuestasCorrectas = pregunta.ConsecutivosRespuestasCorrecta.Trim().ToCharArray();

            Array.Sort(arrRespuestasCorrectas);

            string rtasCorrectas = new string(arrRespuestasCorrectas);

            bool calificacion = rtasCorrectas == rtasUsuario ? true : false;

            return calificacion;

        }

        public bool CalificarPregunta(PreguntaAleatoria pregunta, string respuestas)
        {            
            char[] arrRespuestasUsuario = respuestas.ToCharArray();

            Array.Sort(arrRespuestasUsuario);

            string rtasUsuario = new string(arrRespuestasUsuario);            

            char[] arrRespuestasCorrectas = pregunta.ConsecutivosRespuestasCorrecta.Trim().ToCharArray();

            Array.Sort(arrRespuestasCorrectas);

            string rtasCorrectas = new string(arrRespuestasCorrectas);

            bool calificacion = rtasCorrectas == rtasUsuario ? true : false;

            return calificacion;

        }

        #endregion

        #region Verificar preguntas suficientes en habilidades

        public bool VerificarPreguntasSuficientes(string claveExamen)
        {
            bool resultado = true;

            var habilidades = new LogicaDeNegocios.Habilidades().ObtenerHabilidades(claveExamen);

            var preguntas = this.ObtenerPreguntas();

            foreach (var habilidad in habilidades)
            {
                short idHabilidad = habilidad.Id;

                short noPreguntasEnHabilidadEspecificado = habilidad.Numero;

                int noPreguntasEnHabilidadExistentes = preguntas.Where(p => p.HabilidadesId == idHabilidad).Count();

                if (noPreguntasEnHabilidadExistentes < noPreguntasEnHabilidadEspecificado)
                {
                    resultado = false;
                    break;
                }
            }

            return resultado;

        }
        
        #endregion


        #endregion


    }
}
